﻿using System;
using System.Collections.Generic;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
using System.Text.RegularExpressions;

namespace RegExStudio.Xml
{
    /// <summary>
    /// RegEx Sammlung die im Programm bearbeitet wird
    /// </summary>
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)]
    [System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)]
    public class RegExSet
    {
        private string _fileName = string.Empty;

        /// <summary>
        /// Dateiname des RegExSet
        /// Wenn noch nicht gespeichert wurde string.Empty
        /// </summary>
        public string FileName
        {
            get { return _fileName; }
            set { _fileName = value; }
        }

        /// <summary>
        /// Läd ein RegExSet aus der angegebenen Datei und DeSerialisiert es
        /// </summary>
        /// <param name="fileName">Name der Datei die geöffnet werden soll</param>
        /// <returns>Ein RegExSet Objekt das im Programm bearbeitet wird</returns>
        public static RegExSet LoadFromFile(string fileName)
        {
            RegExSet regExSet = null;
            FileStream fs = null;

            try
            {
                XmlSerializer serializer = new XmlSerializer(typeof(RegExSet));
                fs = new FileStream(fileName, FileMode.Open);
                regExSet = (RegExSet)serializer.Deserialize(fs);
                regExSet.FileName = fileName;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                }
            }

            return regExSet;
        }
 
        /// <summary>
        /// Speichert das RegExSet in der schon vorhandenen Datei
        /// Darf nur benutzt werden wenn das RegExSet schon einen Dateinamen hat
        /// </summary>
        /// <exception cref="exNoFileName">
        /// Wenn kein Dateiname angegeben wurde 
        /// </exception>
        public void SaveToFile()
        {
            if (_fileName != string.Empty)
            {
                SaveToFile(_fileName);
            }
            else
            {
                Exception exNoFileName = new Exception();
                throw exNoFileName;
            }
        }

        /// <summary>
        /// Speichert dieses RegExSet in der angegebenen Datei
        /// </summary>
        /// <param name="fileName">Vollständiger Name der Datei mit Pfad</param>
        public void SaveToFile(string fileName)
        {
            FileStream fs = null;

            try
            {
                _fileName = fileName;
                XmlSerializer serializer = new XmlSerializer(typeof(RegExSet));
                fs = new FileStream(fileName, FileMode.Create);
                serializer.Serialize(fs, this);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                }
            }
        }

        /// <summary>
        /// Initialisiert das RegExSet wenn es neu erstellt wurde
        /// </summary>
        public void InitRegExSet()
        {
            _items = new List<RegExSetRegEx>();
            _items.Clear();
            RegExSetRegEx newRegEx = new RegExSetRegEx();
            newRegEx.Name = Properties.Resources.DefaultRegExName;
            _items.Add(newRegEx);
        }

        /// <summary>
        /// Fügt der Sammlung eine RegEx hinzu
        /// </summary>
        /// <param name="regEx"></param>
        public void AddItem(RegExSetRegEx regEx)
        {
            _items.Add(regEx);
        }

        /// <summary>
        /// Entfernt eine RegEx aus der Sammlung
        /// </summary>
        /// <param name="regEx">Die RegEx die entfernt werden soll</param>
        public void RemoveItem(RegExSetRegEx regEx)
        {
            _items.Remove(regEx);
        }

        /// <summary>
        /// Entfernt alle Items aus der Sammlung und erstellt eine neue RegEx
        /// </summary>
        public void ClearItems()
        {
            _items.Clear();
            _items.Add(new RegExSetRegEx());
        }

        private List<RegExSetRegEx> _items;

        [System.Xml.Serialization.XmlElementAttribute("RegEx", Form = System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public List<RegExSetRegEx> Items
        {
            get
            {
                return this._items;
            }
            set
            {
                this._items = value;
            }
        }

    }

    /// <summary>
    /// Eine RegEx mit den zusätzlichen Informationen die bearbeitet werden
    /// </summary>
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)]
    public partial class RegExSetRegEx
    {

        private string _name;

        private uint _options;

        private bool _optionsSpecified;

        private string _pattern;

        private string _input;

        private string _replacements;

        /// <summary>
        /// Der Name der RegEx die im TabReiter angezeigt wird
        /// </summary>
        [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public string Name
        {
            get
            {
                return this._name;
            }
            set
            {
                this._name = value;
            }
        }

        /// <summary>
        /// Die Optionen die in RegexOptions enthalten sind in Form eine uint
        /// </summary>
        [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public uint Options
        {
            get
            {
                return this._options;
            }
            set
            {
                this._options = value;
            }
        }

        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool OptionsSpecified
        {
            get
            {
                return this._optionsSpecified;
            }
            set
            {
                this._optionsSpecified = value;
            }
        }

        /// <summary>
        /// Das RegEx Pattern
        /// </summary>
        [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public string Pattern
        {
            get
            {
                return this._pattern;
            }
            set
            {
                this._pattern = value;
            }
        }

        /// <summary>
        /// Die Eingabe mit die mit der RegEx geprüft wird
        /// </summary>
        [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public string Input
        {
            get
            {
                return this._input;
            }
            set
            {
                this._input = value;
            }
        }

        /// <summary>
        /// Der Replacement String zur RegEx
        /// </summary>
        [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public string Replacements
        {
            get
            {
                return this._replacements;
            }
            set
            {
                this._replacements = value;
            }
        }
    }
}